package com.dc.toolkit.guava.collect;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Description: Guava_Lists 测试类
 * @author: gdc
 * @date: 2021/5/14
 * @version 1.0
 */
public class ListsTest {

    /**
     * 测试       创建 ArrayList
     */
    @Test
    public void testNewArrayList(){
        List<Object> list1 = Lists.newArrayList();

        List<String> list2 = Lists.newArrayList("1", "2", "3");

        /**
         * 1、确定你的list装多少个元素，不会改变，使用newArrayListWithCapacity（），
         *      如果容器超过定义size，它会自动扩容，不用担心容量不够。扩容后，会将原来的数组复制到新的数组中，但扩容会带来一定的性能影响：包括开辟新空间，copy数据，耗时，耗性能
         *
         * 2、不确定你的list装多少个元素，但差别不会太大，使用newArrayListWithExpectedSize（），
         *      会直接创建一个指定size的容器，但它会通过一条公式计算来进行扩容 （
         *          5L + (long)arraySize + (long)(arraySize / 10)
         *      ），例如，创建一个10个size的容器，那么 5+10 + （10/10） = 16，当容器添加第17个数据时，这个容器才会进行扩容，优点：节约内存，节约时间，节约性能，
         */
        // 初始化指定大小的列表
        List<Integer> listWithCapacity = Lists.newArrayListWithCapacity(2);
        System.out.printf("List当前的大小为：%s， 元素为：%s%n", listWithCapacity.size(), listWithCapacity);
        listWithCapacity.add(1);
        listWithCapacity.add(2);
        listWithCapacity.add(3);
        System.out.printf("List当前的大小为：%s， 元素为：%s%n", listWithCapacity.size(), listWithCapacity);

        // 通过指定大小创建List
        ArrayList<Object> listWithExpectedSize = Lists.newArrayListWithExpectedSize(2);
        System.out.printf("%nList当前的大小为：%s， 元素为：%s%n", listWithExpectedSize.size(), listWithExpectedSize);
        listWithExpectedSize.add(1);
        listWithExpectedSize.add(2);
        listWithExpectedSize.add(3);
        System.out.printf("List当前的大小为：%s， 元素为：%s%n", listWithExpectedSize.size(), listWithExpectedSize);
    }

    /**
     * 测试       创建 LinkedList
     */
    @Test
    public void testNewLinkedList(){
        List<Object> list1 = Lists.newLinkedList();

    }

    /**
     * 测试       创建 CopyOnWriteArrayList
     */
    @Test
    public void testNewCopyOnWriteArrayList(){
        CopyOnWriteArrayList<Object> list = Lists.newCopyOnWriteArrayList();

        CopyOnWriteArrayList<Object> list2 = Lists.newCopyOnWriteArrayList(Iterables.concat());
    }

    /**
     * 测试       将列表，根据指定的 大小进行拆分为多个List
     */
    @Test
    public void testPartition(){
        List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);

        List<List<Integer>> result = Lists.partition(list, 2);
        System.out.println("size = " + result.size());
        result.forEach(System.out::println);
    }

    /**
     * 测试       拆分字符串为字符列表
     */
    @Test
    public void testCharactersOf(){
        ImmutableList<Character> list = Lists.charactersOf("abcdef");
        System.out.println(list);
    }

    /**
     * 测试       list倒序
     */
    @Test
    public void testReverse(){
        List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
        List<Integer> list2 = Lists.reverse(list1);
        System.out.println("原List=" + list1);
        System.out.println("反转后的List=" + list2);
    }
}
